home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / dev / gui / MultiDesktop.lha / MultiDesktop / pntr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-27  |  8.6 KB  |  407 lines
  1. /* Pointer-Verwaltung */
  2. #include "multiwindows.h"
  3. #include "iff-ilbm.h"
  4.  
  5. extern struct MultiWindowsBase *MultiWindowsBase;
  6. extern struct ExecBase         *SysBase;
  7. extern struct IntuitionBase    *IntuitionBase;
  8.  
  9. void ShowPointer();
  10. void SetPointerColors();
  11.  
  12. /* ---- Pointer entfernen */
  13. void UnLoadPointer(po)
  14.  struct Pointer *po;
  15. {
  16.  int i;
  17.  
  18.  if(po)
  19.   {
  20.    i=0;
  21.    Forbid();
  22.    po->UserCount--;
  23.    if(po->UserCount==0) {
  24.     if(po->Node.ln_Succ!=NULL)
  25.       { Remove(po); MultiWindowsBase->PointerCount--; i=1; }}
  26.    Permit();
  27.  
  28.    if(i==1)
  29.     {
  30.      if(po->PointerImage) FreeVec(po->PointerImage);
  31.      FreeVec(po);
  32.     }
  33.   }
  34. }
  35.  
  36. /* ---- Pointer laden */
  37. struct Pointer *LoadPointer(name)
  38.  UBYTE *name;
  39. {
  40.  struct Pointer    *po;
  41.  struct FileLock   *lock,*syslock;
  42.  struct FileHandle *fh;
  43.  struct BMHD        bmhd;
  44.  struct GRAB        grab;
  45.  struct PNTR        pntr;
  46.  BOOL               HasBMHD,HasBODY,HasGRAB,okay;
  47.  UBYTE              id[60];
  48.  ULONG              size,res;
  49.  int                i;
  50.  
  51.  for(i=0;i<strlen(name);i++)
  52.    id[i]=tolower(name[i]);
  53.  id[i]=0x00;
  54.  Forbid();
  55.  po=FindName(&MultiWindowsBase->PointerList,&id);
  56.  if(po) po->UserCount++;
  57.  Permit();
  58.  if(po) return(po);
  59.  
  60.  lock=Lock(MultiWindowsBase->PointerDir,ACCESS_READ);
  61.  if(lock) syslock=CurrentDir(lock); else syslock=NULL;
  62.  fh=Open(name,MODE_OLDFILE);
  63.  if(syslock) CurrentDir(syslock);
  64.  if(lock) UnLock(lock);
  65.  if(fh==NULL) return(NULL);
  66.  
  67.  po=AllocVec(sizeof(struct Pointer)+strlen(name)+2,MEMF_CLEAR|MEMF_PUBLIC);
  68.  if(po!=NULL)
  69.   {
  70.    po->UserCount=1;
  71.    strcpy(&po->Name,&id);
  72.    po->Node.ln_Name=&po->Name;
  73.    po->PointerCount=1;
  74.  
  75.    Read(fh,&id,4L);
  76.    if(!(strncmp(&id,"FORM",4L)))
  77.     {
  78.      Read(fh,&size,4L);
  79.      Read(fh,&id,4L);
  80.      if(!(strncmp(&id,"ILBM",4L)))
  81.       {
  82.        HasBMHD=HasBODY=HasGRAB=po->HasColors=0;
  83.        res=Read(fh,&id,4L);
  84.        while((res==4)&&(HasBODY==FALSE))
  85.         {
  86.          Read(fh,&size,4L);
  87.          if(!(strncmp(&id,"BMHD",4L)))
  88.           {
  89.            Read(fh,&bmhd,sizeof(struct BMHD));
  90.            Seek(fh,-sizeof(struct BMHD),OFFSET_CURRENT);
  91.            if((size % 2)==1) size++;
  92.            Seek(fh,size,OFFSET_CURRENT);
  93.            HasBMHD=TRUE;
  94.           }
  95.          else if(!(strncmp(&id,"GRAB",4L)))
  96.           {
  97.            Read(fh,&grab,sizeof(struct GRAB));
  98.            Seek(fh,-sizeof(struct GRAB),OFFSET_CURRENT);
  99.            if((size % 2)==1) size++;
  100.            Seek(fh,size,OFFSET_CURRENT);
  101.            HasGRAB=TRUE;
  102.           }
  103.          else if(!(strncmp(&id,"PNTR",4L)))
  104.           {
  105.            Read(fh,&pntr,sizeof(struct PNTR));
  106.            Seek(fh,-sizeof(struct PNTR),OFFSET_CURRENT);
  107.            po->PointerCount=pntr.PointerCount;
  108.            if((size % 2)==1) size++;
  109.            Seek(fh,size,OFFSET_CURRENT);
  110.           }
  111.          else if(!(strncmp(&id,"CMAP",4L)))
  112.           {
  113.            Read(fh,&po->Colors,12);
  114.            Seek(fh,-12,OFFSET_CURRENT);
  115.            if((size % 2)==1) size++;
  116.            Seek(fh,size,OFFSET_CURRENT);
  117.            for(i=0;i<12;i++)
  118.              po->Colors[i]=po->Colors[i]/=16;
  119.            po->HasColors=1;
  120.           }
  121.          else if(!(strncmp(&id,"BODY",4L)))
  122.            HasBODY=TRUE;
  123.          else
  124.           {
  125.            if((size % 2)==1) size++;
  126.            Seek(fh,size,OFFSET_CURRENT);
  127.           }
  128.  
  129.          res=Read(fh,&id,4L);
  130.         }
  131.        Seek(fh,-8,OFFSET_CURRENT);
  132.  
  133.        if((HasBODY)&&(HasBMHD))
  134.         {
  135.          if(bmhd.Compression==0)
  136.           {
  137.            if(bmhd.Width<=16)
  138.             {
  139.              if(bmhd.Depth>2) bmhd.Depth=2;
  140.              if(bmhd.Height>18) bmhd.Height=18;
  141.              po->Width=bmhd.Width;
  142.              po->Height=bmhd.Height;
  143.              if(HasGRAB)
  144.               {
  145.                po->HotSpotX=-grab.OffsetX;
  146.                po->HotSpotY=-grab.OffsetY;
  147.               }
  148.              else
  149.               {
  150.                po->HotSpotX=-1;
  151.                po->HotSpotY=-1;
  152.               }
  153.  
  154.              po->PointerSize=size/po->PointerCount;
  155.              po->PointerImage=AllocVec(size,MEMF_CHIP|MEMF_PUBLIC);
  156.              if(po->PointerImage)
  157.               {
  158.                Read(fh,po->PointerImage,size);
  159.               }
  160.              else
  161.               {
  162.                ErrorL(1034,"LoadPointer():\nNot enough chip memory!");
  163.                UnLoadPointer(po);
  164.                po=NULL;
  165.               }
  166.             }
  167.            else
  168.             {
  169.              ErrorL(1035,"LoadPointer():\nPointer width is greater than 16!");
  170.              UnLoadPointer(po);
  171.              po=NULL;
  172.             }
  173.           }
  174.          else
  175.           {
  176.            ErrorL(1033,"LoadPointer():\nPointer files may not be compressed!");
  177.            UnLoadPointer(po);
  178.            po=NULL;
  179.           }
  180.         }
  181.        else
  182.         {
  183.          ErrorL(1032,"LoadPointer():\nInvalid ILBM file!");
  184.          UnLoadPointer(po);
  185.          po=NULL;
  186.         }
  187.       }
  188.      else
  189.       {
  190.        ErrorL(1031,"LoadPointer():\nNo IFF-ILBM file!");
  191.        UnLoadPointer(po);
  192.        po=NULL;
  193.       }
  194.     }
  195.    else
  196.     {
  197.      ErrorL(1030,"LoadPointer():\nNo IFF file format!");
  198.      UnLoadPointer(po);
  199.      po=NULL;
  200.     }
  201.   }
  202.  else
  203.   {
  204.    ErrorL(0,0);
  205.    UnLoadPointer(po);
  206.    po=NULL;
  207.   }
  208.  
  209.  Close(fh);
  210.  if(po)
  211.   {
  212.    Forbid();
  213.    AddTail(&MultiWindowsBase->PointerList,po);
  214.    MultiWindowsBase->PointerCount++;
  215.    Permit();
  216.   }
  217.  return(po);
  218. }
  219.  
  220. /* ---- Pointer benutzen */
  221. void UsePointer(we,po)
  222.  struct WindowEntry *we;
  223.  struct Pointer     *po;
  224. {
  225.  
  226.  if(we->GHWindow!=NULL)
  227.   {
  228.    we->Pointer=po;
  229.    return;
  230.   }
  231.  
  232.  we->Pointer=po;
  233.  ShowPointer(we,po,0);
  234. }
  235.  
  236. /* ---- Pointer laden und darstellen */
  237. BOOL Pointer(name)
  238.  UBYTE *name;
  239. {
  240.  struct WindowEntry *we;
  241.  struct Pointer     *po;
  242.  
  243.  WE;
  244.  if(we==NULL) return(FALSE);
  245.  
  246.  if(name==NULL)
  247.   {
  248.    UsePointer(we,NULL);
  249.    if(we->SysPOAddress) UnLoadPointer(we->SysPOAddress);
  250.    we->SysPOAddress=NULL;
  251.    return(TRUE);
  252.   }
  253.  else
  254.   {
  255.    po=LoadPointer(name);
  256.    if(po)
  257.     {
  258.      UsePointer(we,po);
  259.      if(we->SysPOAddress) UnLoadPointer(we->SysPOAddress);
  260.      we->SysPOAddress=po;
  261.      return(TRUE);
  262.     }
  263.   }
  264.  
  265.  return(FALSE);
  266. }
  267.  
  268. /* ---- Pointer anzeigen */
  269. void ShowPointer(we,po,num)
  270.  struct WindowEntry *we;
  271.  struct Pointer     *po;
  272.  UWORD               num;
  273. {
  274.  int i;
  275.  
  276.  if(!we->Iconify)
  277.   {
  278.    we->ActivePointer=po;
  279.    if(po)
  280.     {
  281.      if(num>=po->PointerCount) num=0;
  282.      we->ActivePointerImage=num;
  283.  
  284.      SetPointer(we->Window,
  285.                 (ULONG)po->PointerImage+(ULONG)num*(ULONG)po->PointerSize,
  286.                 po->Height,po->Width,po->HotSpotX,po->HotSpotY);
  287.     }
  288.    else
  289.     {
  290.      we->ActivePointerImage=0;
  291.      ClearPointer(we->Window);
  292.     }
  293.    SetPointerColors();
  294.   }
  295. }
  296.  
  297. /* ---- Mauszeiger-Animation */
  298. void NextPointer(we)
  299.  struct WindowEntry *we;
  300. {
  301.  
  302.  if(we->ActivePointer)
  303.   {
  304.    if(we->ActivePointer->PointerCount>1)
  305.     {
  306.      we->ActivePointerImage++;
  307.      ShowPointer(we,we->ActivePointer,we->ActivePointerImage);
  308.     }
  309.   }
  310. }
  311.  
  312. /* ---- Nächstes Pointer-Bild darstellen */
  313. void AnimPointer()
  314. {
  315.  struct WindowEntry *we;
  316.  
  317.  WE;
  318.  if(we==NULL) return;
  319.  NextPointer(we);
  320. }
  321.  
  322. /* ---- Standard-Pointer anzeigen */
  323. void StdPointer(num)
  324.  UBYTE num;
  325. {
  326.  UBYTE *name;
  327.  
  328.  name=NULL;
  329.  switch(num)
  330.   {
  331.    case STDP_SLEEP:
  332.      name=MultiWindowsBase->SleepPointerName;
  333.     break;
  334.    case STDP_WORK:
  335.      name=MultiWindowsBase->WorkPointerName;
  336.     break;
  337.    case STDP_HELP:
  338.      name=MultiWindowsBase->HelpPointerName;
  339.     break;
  340.   }
  341.  Pointer(name);
  342. }
  343.  
  344. /* ---- Pointer-Farben setzen */
  345. void SetPointerColors()
  346. {
  347.  UBYTE               array[12];
  348.  APTR                lock;
  349.  int                 i;
  350.  struct Window      *win;
  351.  struct WindowEntry *we;
  352.  struct Pointer     *po;
  353.  
  354.  lock=LockIBase(NULL);
  355.  po=NULL;
  356.  win=IntuitionBase->ActiveWindow;
  357.  if(win!=NULL)
  358.   {
  359.    we=win->UserData;
  360.    if(we!=NULL)
  361.     {
  362.      if(!we->Iconify)
  363.       {
  364.        if(we->ActivePointer!=NULL)
  365.         {
  366.          if(we->ActivePointer->HasColors!=0)
  367.           {
  368.            po=we->ActivePointer;
  369.           }
  370.         }
  371.       }
  372.     }
  373.   }
  374.  else
  375.   {
  376.    UnlockIBase(lock);
  377.    return;
  378.   }
  379.  
  380.  if(po)
  381.    CopyMem(&po->Colors,&array,12);
  382.  else
  383.   {
  384.    /* Farbe 16 */
  385.    array[0]=0;
  386.    array[1]=0;
  387.    array[2]=0;
  388.    /* Farbe 17 */
  389.    array[3]=(MultiWindowsBase->Preferences->color17>>8) & 0xf;
  390.    array[4]=(MultiWindowsBase->Preferences->color17>>4) & 0xf;
  391.    array[5]=(MultiWindowsBase->Preferences->color17>>0) & 0xf;
  392.    /* Farbe 18 */
  393.    array[6]=(MultiWindowsBase->Preferences->color18>>8) & 0xf;
  394.    array[7]=(MultiWindowsBase->Preferences->color18>>4) & 0xf;
  395.    array[8]=(MultiWindowsBase->Preferences->color18>>0) & 0xf;
  396.    /* Farbe 19 */
  397.    array[9]=(MultiWindowsBase->Preferences->color19>>8) & 0xf;
  398.    array[10]=(MultiWindowsBase->Preferences->color19>>4) & 0xf;
  399.    array[11]=(MultiWindowsBase->Preferences->color19>>0) & 0xf;
  400.   }
  401.  
  402.  for(i=0;i<4;i++)
  403.    SetRGB4(ViewPortAddress(win),16+i,array[3*i],array[3*i+1],array[3*i+2]);
  404.  UnlockIBase(lock);
  405. }
  406.  
  407.